package com.ytclub.subject.application.controller;

import com.alibaba.fastjson.JSON;
import com.google.common.base.Preconditions;
import com.ytclub.subject.application.convert.SubjectCategoryDTOConvert;
import com.ytclub.subject.application.convert.SubjectLabelDTOConvert;
import com.ytclub.subject.application.dto.SubjectCategoryDTO;
import com.ytclub.subject.application.dto.SubjectLabelDTO;
import com.ytclub.subject.common.util.LoginUtil;
import com.ytclub.subject.common.entity.Result;
import com.ytclub.subject.domain.entity.SubjectCategoryBO;
import com.ytclub.subject.domain.service.SubjectCategoryDoaminService;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;
import java.util.LinkedList;
import java.util.List;

/**
 * 新增分类控制层
 *
 * @author: HuangQi
 * @date: Created in 21:29 2023/12/14
 * @description:
 */
@RestController
@RequestMapping("/subject/category")
@Slf4j
public class SubjectCategoryController {

    @Resource
    private SubjectCategoryDoaminService subjectCategoryDoaminService;

    /**
     * 新增分类
     *
     * @param subjectCategoryDTO 新增分类的信息
     * @return Result<Boolean>
     */
    @PostMapping("/add")
    public Result<Boolean> add(@RequestBody SubjectCategoryDTO subjectCategoryDTO) {
        try {
            if (log.isInfoEnabled()) {
                log.info("SubjectCategoryController.add.dto:{}", JSON.toJSONString(subjectCategoryDTO));
            }
            // 参数校验
            Preconditions.checkNotNull(subjectCategoryDTO.getCategoryType(), "分类类型不能为空");
            Preconditions.checkArgument(!StringUtils.isBlank(subjectCategoryDTO.getCategoryName()), "分类名称不能为空");
            Preconditions.checkNotNull(subjectCategoryDTO.getParentId(), "父级分类不能为空");

            // 参数转换
            SubjectCategoryBO subjectCategoryBO =
                    SubjectCategoryDTOConvert.INSTANCE.convertDTOToCategoryBO(subjectCategoryDTO);

            // 调用领域层
            Boolean result = subjectCategoryDoaminService.add(subjectCategoryBO);

            // 返回结果
            return Result.ok(result);
        } catch (Exception e) {
            // 异常处理
            log.error("SubjectCategoryController.add.error:{}", e.getMessage(), e);
            return Result.fail("新增分类失败");
        }
    }


    /**
     * 查询岗位大类
     *
     * @return Result<List < SubjectCategoryDTO>> 一级分类列表
     */
    @PostMapping("/queryPrimaryCategory")
    public Result<List<SubjectCategoryDTO>> queryPrimaryCategory(
            @RequestBody SubjectCategoryDTO subjectCategoryDTO) {
        try {
            if (log.isInfoEnabled()) {
                log.info("SubjectCategoryController.queryPrimaryCategory.dto:{}", JSON.toJSONString(subjectCategoryDTO));
            }
            //参数校验
            Preconditions.checkNotNull(subjectCategoryDTO.getCategoryType(), "分类类型不能为空");
            // 调用领域层
            SubjectCategoryBO subjectCategoryBO =
                    SubjectCategoryDTOConvert.INSTANCE.convertDTOToCategoryBO(subjectCategoryDTO);
            subjectCategoryBO.setParentId(0L);
            List<SubjectCategoryBO> subjectCategoryBOList = subjectCategoryDoaminService.queryCategory(subjectCategoryBO);

            // 结果转换
            List<SubjectCategoryDTO> subjectCategoryDTOList = SubjectCategoryDTOConvert.INSTANCE.
                    convertBOToCategoryDTO(subjectCategoryBOList);

            // 返回结果
            return Result.ok(subjectCategoryDTOList);
        } catch (Exception e) {
            // 异常处理
            log.error("SubjectCategoryController.queryPrimaryCategory.error:{}", e.getMessage(), e);
            return Result.fail("查询一级分类失败");
        }
    }

    /**
     * 查询二级分类
     *
     * @param subjectCategoryDTO 二级分类的信息
     * @return Result<List < SubjectCategoryDTO>> 二级分类列表
     */
    @PostMapping("/queryCategoryByPrimary")
    public Result<List<SubjectCategoryDTO>> queryCategoryByPrimary(
            @RequestBody SubjectCategoryDTO subjectCategoryDTO) {
        try {
            if (log.isInfoEnabled()) {
                log.info("SubjectCategoryController.add.dto:{}", JSON.toJSONString(subjectCategoryDTO));
            }
            // 参数校验
            Preconditions.checkNotNull(subjectCategoryDTO.getParentId(), "父级id不能为空");
            SubjectCategoryBO subjectCategoryBO =
                    SubjectCategoryDTOConvert.INSTANCE.convertDTOToCategoryBO(subjectCategoryDTO);

            // 调用领域层,转换结果
            List<SubjectCategoryBO> subjectCategoryBOList = subjectCategoryDoaminService.queryCategory(subjectCategoryBO);
            List<SubjectCategoryDTO> subjectCategoryDTOList = SubjectCategoryDTOConvert.INSTANCE.
                    convertBOToCategoryDTO(subjectCategoryBOList);
            return Result.ok(subjectCategoryDTOList);
        } catch (Exception e) {
            // 异常处理
            log.error("SubjectCategoryController.queryCategoryByPrimary.error:{}", e.getMessage(), e);
            return Result.fail("查询二级分类失败");
        }
    }


    /**
     * 更新分类
     *
     * @param subjectCategoryDTO 更新分类信息
     * @return Result<Boolean> 更新结果
     */
    @PostMapping("/update")
    public Result<Boolean> update(
            @RequestBody SubjectCategoryDTO subjectCategoryDTO) {
        try {
            if (log.isInfoEnabled()) {
                log.info("SubjectCategoryController.update.dto:{}", JSON.toJSONString(subjectCategoryDTO));
            }
            // 参数校验
            Preconditions.checkNotNull(subjectCategoryDTO.getParentId(), "父级id不能为空");

            // 参数转换
            SubjectCategoryBO subjectCategoryBO =
                    SubjectCategoryDTOConvert.INSTANCE.convertDTOToCategoryBO(subjectCategoryDTO);

            // 调用领域层,转换结果
            Boolean result = subjectCategoryDoaminService.update(subjectCategoryBO);
            return Result.ok(result);
        } catch (Exception e) {
            // 异常处理
            log.error("SubjectCategoryController.update.error:{}", e.getMessage(), e);
            return Result.fail("更新分类失败");
        }
    }

    /**
     * 删除分类
     *
     * @param subjectCategoryDTO 删除分类的信息
     * @return Result<Boolean> 删除结果
     */
    @PostMapping("/delete")
    public Result<Boolean> delete(
            @RequestBody SubjectCategoryDTO subjectCategoryDTO) {
        try {
            if (log.isInfoEnabled()) {
                log.info("SubjectCategoryController.delete.dto:{}", JSON.toJSONString(subjectCategoryDTO));
            }
            // 参数校验
            Preconditions.checkNotNull(subjectCategoryDTO.getId(), "id不能为空");

            // 参数转换
            SubjectCategoryBO subjectCategoryBO =
                    SubjectCategoryDTOConvert.INSTANCE.convertDTOToCategoryBO(subjectCategoryDTO);

            // 调用领域层,转换结果
            Boolean result = subjectCategoryDoaminService.delete(subjectCategoryBO);
            return Result.ok(result);
        } catch (Exception e) {
            // 异常处理
            log.error("SubjectCategoryController.delete.error:{}", e.getMessage(), e);
            return Result.fail("删除分类失败");
        }
    }

    /**
     * 查询分类及标签一次性
     *
     * @return Result<List < SubjectCategoryDTO>> 一级分类列表
     */
    @PostMapping("/queryCategoryAndLabel")
    public Result<List<SubjectCategoryDTO>> queryCategoryAndLabel(
            @RequestBody SubjectCategoryDTO subjectCategoryDTO) {
        try {
            if (log.isInfoEnabled()) {
                log.info("SubjectCategoryController.queryCategoryAndLabel.dto:{}", JSON.toJSONString(subjectCategoryDTO));
            }
            String loginId = LoginUtil.getLoginId();
            log.info("SubjectCategoryController.queryCategoryAndLabel.loginId:{}", loginId);
            //参数校验
            Preconditions.checkNotNull(subjectCategoryDTO.getId(), "分类id不能为空");
            // 调用领域层
            SubjectCategoryBO subjectCategoryBO =
                    SubjectCategoryDTOConvert.INSTANCE.convertDTOToCategoryBO(subjectCategoryDTO);

            List<SubjectCategoryBO> subjectCategoryBOList = subjectCategoryDoaminService.queryCategoryAndLabel(subjectCategoryBO);

            // 结果转换
            List<SubjectCategoryDTO> dtoList = new LinkedList<>();
            subjectCategoryBOList.forEach(bo -> {
                SubjectCategoryDTO dto = SubjectCategoryDTOConvert.INSTANCE.convertBOToDTO(bo);
                List<SubjectLabelDTO> labelDTOList = SubjectLabelDTOConvert.INSTANCE.convertBOToLabelyDTO(bo.getLabelBOList());
                dto.setLabelDTOList(labelDTOList);
                dtoList.add(dto);
            });

            // 返回结果
            return Result.ok(dtoList);
        } catch (Exception e) {
            // 异常处理
            log.error("SubjectCategoryController.queryCategoryAndLabel.error:{}", e.getMessage(), e);
            return Result.fail("查询分类及标签一次性失败");
        }
    }


}
